﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>


//本题要求实现一个函数，对给定的正整数N，打印从1到N的全部正整数。
//其中N是用户传入的参数。该函数必须将从1到N的全部正整数顺序打印出来，每个数字占1行。


//void PrintN(int N);//函数声明
//
//int main()
//{
//    int N;
//
//    scanf("%d", &N);
//    PrintN(N);
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//void PrintN(int N)
//{
//    for (int i = 1; i <= N; i++)
//    {
//        printf("%d\n", i);
//        
//    }
//}



//本题要求实现一个函数，计算阶数为n，系数为a[0] ... a[n]的多项式f(x)=∑(n,i=0)(a^i*x^i)在x的值
//其中n是多项式的阶数，a[]中存储系数，x是给定点。函数须返回多项式f(x)的值。

//没得到满分
//#define MAXN 10
//
//double f(int n, double a[], double x);
//
//int main()
//{
//    int n, i;
//    double a[MAXN], x;
//
//    scanf("%d %lf", &n, &x);
//    for (i = 0; i <= n; i++)
//        scanf("%lf", &a[i]);
//    printf("%.1f\n", f(n, a, x));
//    return 0;
//}
//
//double f(int n, double a[], double x)
//{
//    double sum = 0;
//    for (int i = 0; i <= n; i++)
//    {
//        double X = 1;
//        if (i != 0)
//        {
//            for (int j = 1; j <= i; j++)
//            {
//                X *= x;
//            }
//        }
//        sum += a[i] * X;
//    }
//    double tmp = sum * 100;
//    if ((int)tmp % 10 >= 5)//实现百分位四舍五入
//    {
//        return (tmp + 10) * 0.01;
//    }
//    else
//    {
//        return sum;
//    }
//}



//本题要求实现一个函数，求给定的N个整数的和。
//其中给定整数存放在数组List[]中，正整数N是数组元素个数。该函数须返回N个List[]元素的和。
//#include <stdio.h>
//
//#define MAXN 10
//
//int Sum(int List[], int N);
//
//int main()
//{
//    int List[MAXN], N, i;
//
//    scanf("%d", &N);
//    for (i = 0; i < N; i++)
//        scanf("%d", &List[i]);
//    printf("%d\n", Sum(List, N));
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//int Sum(int List[], int N)
//{
//    int sum = 0;
//    for (int i = 0; i < N; i++)
//    {
//        sum += List[i];
//    }
//    return sum;
//}



//本题要求实现一个函数，求N个集合元素S[]的平均值，其中集合元素的类型为自定义的ElementType。
//其中给定集合元素存放在数组S[]中，正整数N是数组元素个数。
//该函数须返回N个S[]元素的平均值，其值也必须是ElementType类型。
//#include <stdio.h>
//
//#define MAXN 10
//typedef float ElementType;
//
//ElementType Average(ElementType S[], int N);
//
//int main()
//{
//    ElementType S[MAXN];
//    int N, i;
//
//    scanf("%d", &N);
//    for (i = 0; i < N; i++)
//        scanf("%f", &S[i]);
//    printf("%.2f\n", Average(S, N));
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//ElementType Average(ElementType S[], int N)
//{
//    ElementType sum = 0;
//    for (int i = 0; i < N; i++)
//    {
//        sum += S[i];
//    }
//    return sum / N ;
//    


//本题要求实现一个函数，求N个集合元素S[]中的最大值，其中集合元素的类型为自定义的ElementType。
//其中给定集合元素存放在数组S[]中，正整数N是数组元素个数。
//该函数须返回N个S[]元素中的最大值，其值也必须是ElementType类型。
//#include <stdio.h>
//
//#define MAXN 10
//typedef float ElementType;
//
//ElementType Max(ElementType S[], int N);
//
//int main()
//{
//    ElementType S[MAXN];
//    int N, i;
//
//    scanf("%d", &N);
//    for (i = 0; i < N; i++)
//        scanf("%f", &S[i]);
//    printf("%.2f\n", Max(S, N));
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//ElementType Max(ElementType S[], int N)
//{
//    ElementType max = S[0];
//    for (int i = 0; i < N; i++) 
//    {
//        if (S[i] >= max)
//        {
//            max = S[i];
//        }
//    }
//    return max;
//}




//本题要求实现一个函数，求单链表L结点的阶乘和。这里默认所有结点的值非负，且题目保证结果在int范围内。
//#include <stdio.h>
//#include <stdlib.h>
//
//typedef struct Node* PtrToNode;
//struct Node {
//    int Data; /* 存储结点数据 */
//    PtrToNode Next; /* 指向下一个结点的指针 */
//};
//typedef PtrToNode List; /* 定义单链表类型 */
//
//int FactorialSum(List L);
//
//int main()
//{
//    int N, i;
//    List L, p;
//
//    scanf("%d", &N);
//    L = NULL;
//    for (i = 0; i < N; i++) {
//        p = (List)malloc(sizeof(struct Node));
//        scanf("%d", &p->Data);
//        p->Next = L;  L = p;
//    }
//    printf("%d\n", FactorialSum(L));
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//int FactorialSum(List L)
//{
//    int sum = 0;
//    while (L!= NULL)
//    {
//        int fact = 1;
//        for (int i = 1; i <= L->Data; i++)
//        {
//            fact *= i;
//        }
//        sum += fact;
//        L = L->Next;
//    }
//    return sum;
//}






//本题要求实现一个函数，判断任一给定整数N是否满足条件：它是完全平方数，又至少有两位数字相同，如144、676等。
//其中N是用户传入的参数。如果N满足条件，则该函数必须返回1，否则返回0。
//#include <stdio.h>
//#include <math.h>
//
//int IsTheNumber(const int N);
//
//int main()
//{
//    int n1, n2, i, cnt;
//
//    scanf("%d %d", &n1, &n2);
//    cnt = 0;
//    for (i = n1; i <= n2; i++) {
//        if (IsTheNumber(i))
//            cnt++;
//    }
//    printf("cnt = %d\n", cnt);
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//int IsTheNumber(const int N)
//{
//    int flag = 0;
//    for (int i = 0; i < N / 2; i++)
//    {
//        if (i * i == N)
//        {
//            flag = 1;
//            break;
//        }
//    }
//    if (flag == 1)
//    {
//        flag = 0;
//        int tmp = N;
//        int arr[20] = { 0 };
//        int i = 0;
//        while (tmp)
//        {
//            arr[i] = tmp % 10;
//            tmp /= 10;
//            i++;
//        }
//        for (i=i-1; i >= 0; i--)
//        {
//            for (int j = 0; j < i; j++)
//            {
//                if (arr[i] == arr[j])
//                {
//                    flag = 1;
//                    break;
//                }
//            }
//            if (flag == 1)
//            {
//                break;
//            }
//        }
//        if (flag == 1)
//        {
//            return 1;
//        }
//        else
//        {
//            return 0;
//        }
//    }
//    else
//    {
//        return 0;
//    }
//
//}





//本题要求实现一个计算非负整数阶乘的简单函数。
//其中N是用户传入的参数，其值不超过12。如果N是非负整数，则该函数必须返回N的阶乘，否则返回0。
//#include <stdio.h>
//
//int Factorial(const int N);
//
//int main()
//{
//    int N, NF;
//
//    scanf("%d", &N);
//    NF = Factorial(N);
//    if (NF)  printf("%d! = %d\n", N, NF);
//    else printf("Invalid input\n");
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//int Factorial(const int N)
//{
//    
//    if (N < 0)
//    {
//        return 0;
//    }
//    
//    int ret = 1;
//    for (int i = 1; i <= N; i++)
//    {
//        ret *= i;
//    }
//    return ret;
//}






//本题要求实现一个函数，可统计任一整数中某个位数出现的次数。例如-21252中，2出现了3次，则该函数应该返回3。
//其中N和D都是用户传入的参数。N的值不超过int的范围；D是[0, 9]区间内的个位数。函数须返回N中D出现的次数。

//#include <stdio.h>
//
//int Count_Digit(const int N, const int D);
//
//int main()
//{
//    int N, D;
//
//    scanf("%d %d", &N, &D);
//    printf("%d\n", Count_Digit(N, D));
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//int Count_Digit(const int N, const int D)
//{
//    int ret = 0;
//    int tmp = 0;
//    if (N > 0)
//    {
//        tmp = N;
//    }
//    else if (N < 0)
//    {
//        tmp = -N;
//    }
//    else
//    {
//        if (D == 0)
//        {
//            return 1;
//        }
//    }
//    while (tmp)
//    {
//        int i = tmp % 10;
//        if (i == D)
//        {
//            ret++;
//        }
//        tmp/= 10;
//    }
//    return ret;
//}








//本题要求实现一个打印非负整数阶乘的函数。
//其中N是用户传入的参数，其值不超过1000。如果N是非负整数，
//则该函数必须在一行中打印出N!的值，否则打印“Invalid input”。
//#include <stdio.h>
//
//void Print_Factorial(const int N);
//
//int main()
//{
//    int N;
//
//    scanf("%d", &N);
//    Print_Factorial(N);
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//void Print_Factorial(const int N)
//{
//    if (N < 0)
//    {
//        printf("Invalid input\n");
//    }
//    else if(N>0)
//    {
//        #define MAXSIZE 2700
//        int arr[MAXSIZE] = { -1 };
//        for (int s = 0; s < MAXSIZE; s++)
//            {
//                arr[s] = -1;
//            }
//            int index = MAXSIZE - 1;
//            int tmp = N;
//            while (tmp)
//            {
//                arr[index] = tmp % 10;
//                tmp /= 10;
//                index--;
//            }
//            arr[index] = 0;
//            int x = N - 1;
//            while (x)
//            {
//                for (int i = MAXSIZE - 1; i > index; i--)
//                {
//                    arr[i] *= x;
//                }
//
//                for (int j = MAXSIZE - 1; j > index; j--)
//                {
//                    while (arr[j] >= 10)
//                    {
//                        int p = j;
//                        while (arr[p] >= 10)
//                        {
//                            arr[p - 1] += arr[p] / 10;
//                            arr[p] %= 10;
//                            if (p - 1 == index)
//                            {
//                                index--;
//                                arr[index] = 0;
//                            }
//                            p--;
//                        }
//                    }
//
//                }
//                x--;
//            }
//            int n = 0;
//            for (n = 0; n < MAXSIZE; n++)
//            {
//                if (arr[n] == 0)
//                {
//                    break;
//                }
//            }
//            for (n = n + 1; n < MAXSIZE; n++)
//            {
//                printf("%d", arr[n]);
//            }
//            putchar('\n');
//    }
//    else
//    {
//        printf("1\n");
//    }
//}
// 
// 
// 
// 
// 
// 
// C语言存储超大数
//#define MAXSIZE 1000
//int main()
//{
//    int N = 100;
//    int arr[MAXSIZE] = { -1 };
//    for (int s = 0; s < MAXSIZE; s++)
//    {
//        arr[s] = -1;
//    }
//    int index = MAXSIZE-1;
//    int tmp = N;
//    while (tmp)
//    {
//        arr[index] = tmp % 10;
//        tmp /= 10;
//        index--;
//    }
//    arr[index] = 0;
//    int x = N - 1;
//    while (x)
//    {
//        for (int i = MAXSIZE-1; i > index; i--)
//        {
//            arr[i] *= x;
//        }
//        
//        for (int j = MAXSIZE-1; j > index; j--)
//        {
//            while (arr[j] >= 10)
//            {
//                int p = j;
//                while (arr[p] >= 10)
//                {
//                    arr[p - 1] += arr[p] / 10;
//                    arr[p] %= 10;
//                    if (p - 1 == index)
//                    {
//                        index--;
//                        arr[index] = 0;
//                    }
//                    p--;
//                }
//            }
//            
//        }
//        x--;
//    }
//    int n = 0;
//    for (n = 0; n < MAXSIZE; n++)
//    {
//        if (arr[n] == 0)
//        {
//            break;
//        }
//    }
//    for (n = n + 1; n < MAXSIZE; n++)
//    {
//        printf("%d", arr[n]);
//    }
//    
//    return 0;
//
//}





//本题要求实现一个函数，求N个集合元素A[]的中位数，即序列中第⌊(N+1)/2⌋大的元素。
//其中集合元素的类型为自定义的ElementType。
//其中给定集合元素存放在数组A[]中，正整数N是数组元素个数。
//该函数须返回N个A[]元素的中位数，其值也必须是ElementType类型。

//#include <stdio.h>
//
//#define MAXN 10
//typedef float ElementType;
//
//ElementType Median(ElementType A[], int N);
//
//int main()
//{
//    ElementType A[MAXN];
//    int N, i;
//
//    scanf("%d", &N);
//    for (i = 0; i < N; i++)
//        scanf("%f", &A[i]);
//    printf("%.2f\n", Median(A, N));
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//ElementType Median(ElementType A[], int N)
//{
//    for (int i = 0; i < N - 1; i++)
//    {
//        for (int j = 0; j < N - 1 - i; j++)
//        {
//            if (A[j] > A[j + 1])
//            {
//                ElementType tmp = A[j];
//                A[j] = A[j + 1];
//                A[j + 1] = tmp;
//            }
//        }
//    }
//    
//    if (N % 2 == 1)
//    {
//        return A[(N + 1) / 2 - 1];
//    }
//    else
//    {
//        return (A[(N + 1) / 2 - 1] + A[(N + 1) / 2]) / 2;
//    }
//}





//本题要求实现判断给定整数奇偶性的函数。
//其中n是用户传入的整型参数。当n为偶数时，函数返回1；n为奇数时返回0。注意：0是偶数。

//#include <stdio.h>
//
//int even(int n);
//
//int main()
//{
//    int n;
//
//    scanf("%d", &n);
//    if (even(n))
//        printf("%d is even.\n", n);
//    else
//        printf("%d is odd.\n", n);
//
//    return 0;
//}
//
///* 你的代码将被嵌在这里 */
//
//int even(int n)
//{
//    int tmp = n;
//    if (n < 0)
//    {
//        tmp = -n;
//    }
//    if (tmp % 2==0)
//    {
//        return 1;
//    }
//    else
//    {
//        return 0;
//    }
//}







//给一个严格递增数列，函数int Search_Bin(SSTable T, KeyType k)用来二分地查找k在数列中的位置。
//其中T是有序表，k是查找的值。


//#include <iostream>
//using namespace std;//这个可能是c++里面的，但是我已经创建了c文件，懒得改了
//
//#define MAXSIZE 50
//typedef int KeyType;
//
//typedef  struct
//{
//    KeyType  key;
//} ElemType;
//
//typedef  struct
//{
//    ElemType* R;
//    int  length;
//} SSTable;
//
//void  Create(SSTable& T)
//{
//    int i;
//    T.R = new ElemType[MAXSIZE + 1];
//    cin >> T.length;
//    for (i = 1; i <= T.length; i++)
//        cin >> T.R[i].key;
//}
//
//int  Search_Bin(SSTable T, KeyType k);
//
//int main()
//{
//    SSTable T;  KeyType k;
//    Create(T);
//    cin >> k;
//    int pos = Search_Bin(T, k);
//    if (pos == 0) cout << "NOT FOUND" << endl;
//    else cout << pos << endl;
//    return 0;
//}
//
///* 请在这里填写答案 */
//int  Search_Bin(SSTable T, KeyType k)
//{
//    int left = 0;
//    int right = T.length-1;
//    while (left<=right)
//    {
//        if (T.R[(left + right) / 2].key >= k)
//        {
//            left = (left + right) / 2;
//        }
//        else if (T.R[(left + right) / 2].key <= k)
//        {
//            right = (left + right) / 2;
//        }
//        else
//        {
//            return (left + right) / 2+1;
//        }
//    }
//    return 0;
//}



//如果已知英制长度的英尺foot和英寸inch的值，那么对应的米是(foot+inch/12)×0.3048。
//现在，如果用户输入的是厘米数，那么对应英制长度的英尺和英寸是多少呢？别忘了1英尺等于12英寸。

//输入格式：
//输入在一行中给出1个正整数，单位是厘米。

//输出格式：
//在一行中输出这个厘米数对应英制长度的英尺和英寸的整数值，中间用空格分开。

//int main()
//{
//	int centimeter = 0;
//	scanf("%d", &centimeter);
//	int foot = 0;
//	int inch = 0;
//	double meter = centimeter / 100.0;
//	foot = (int)(meter / 0.3048);
//	inch = (int)((meter / 0.3048 - foot) * 12);
//	printf("%d %d\n", foot, inch);
//
//	return 0;
//}



//有时候人们用四位数字表示一个时间，
//比如 1106 表示 11 点零 6 分。现在，你的程序要根据起始时间和流逝的时间计算出终止时间。

//int main()
//{
//	int hour = 0;
//	int minute = 0;
//	int scan = 0;
//	int x = 0;
//	scanf("%d %d", &scan,&x);
//	minute = scan % 100;
//	hour = scan / 100;
//	if (x >= 0)
//	{
//		hour += x / 60;
//		minute += (x - ((x / 60) * 60));
//	}
//	else
//	{
//		x = -x;
//		hour -= x / 60;
//		if (minute < (x - ((x / 60) * 60)))
//		{
//			hour--;
//			minute += 60;
//			minute -= (x - ((x / 60) * 60));
//		}
//		else
//		{
//			minute -= (x - ((x / 60) * 60));
//		}
//	}
//	if (minute >= 60)
//	{
//		hour += minute / 60;
//		minute %= 60;
//	}
//	if (minute < 10)
//	{
//		printf("%d0%d", hour, minute);
//	}
//	else
//	{
//		printf("%d%d", hour, minute);
//
//}





//程序每次读入一个正3位数，然后输出按位逆序的数字。
//注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入700，输出应该是7。

//输入格式：
//每个测试是一个3位的正整数。

//输出格式：
//输出按位逆序的数。
//int main()
//{
//	int mum = 0;
//	scanf("%d", &mum);
//	int flag = 1;
//	while (mum)
//	{
//		if (mum % 10 == 0&&flag==1)
//		{
//			mum /= 10;
//			continue;
//		}
//		else
//		{
//			flag = 0;
//			printf("%d", mum % 10);
//			mum /= 10;
//		}
//	}
//}




//BCD数是用一个字节来表达两位十进制的数，每四个比特表示一位。
//所以如果一个BCD数的十六进制是0x12，它表达的就是十进制的12。但是小明没学过BCD，
//把所有的BCD数都当作二进制数转换成十进制输出了。于是BCD的0x12被输出成了十进制的18了！

//现在，你的程序要读入这个错误的十进制数，然后输出正确的十进制数。
//提示：你可以把18转换回0x12，然后再转换回12。

//int main()
//{
//	int errormum = 0;
//	scanf("%d", &errormum);
//	if (errormum == 0)
//	{
//		printf("0\n");
//	}
//	else
//	{
//		printf("%d%d", errormum / 16, errormum - (errormum / 16) * 16);
//	}
//	return 0;
//}



//本题要求编写程序，按照规定格式输出表格。


//输出格式：
//要求严格按照给出的格式输出下列表格：
//
//------------------------------------
//Province      Area(km2)   Pop.(10K)
//------------------------------------
//Anhui         139600.00   6461.00
//Beijing        16410.54   1180.70
//Chongqing      82400.00   3144.23
//Shanghai        6340.50   1360.26
//Zhejiang      101800.00   4894.00
//------------------------------------
//int main()
//{
//	printf("------------------------------------\n");
//	printf("Province      Area(km2)   Pop.(10K)\n");
//	printf("------------------------------------\n");
//	printf("Anhui         139600.00   6461.00\n");
//	printf("Beijing        16410.54   1180.70\n");
//	printf("Chongqing      82400.00   3144.23\n");
//	printf("Shanghai        6340.50   1360.26\n");
//	printf("Zhejiang      101800.00   4894.00\n");
//	printf("------------------------------------\n");
//
//}







//本题要求编写程序，顺序读入浮点数1、整数、字符、浮点数2，
//再按照字符、整数、浮点数1、浮点数2的顺序输出。
//int main()
//{
//	double x1 = 0;
//	double x2 = 0;
//	int a = 0;
//	char b = 0;
//	scanf("%lf %d %c %lf", &x1, &a, &b, &x2);
//	printf("%c %d %.2lf %.2lf", b, a, x1, x2);
//	return 0;
//}



//编写一个程序，要求用户输入24小时制的时间，然后显示12小时制的时间。
//int main()
//{
//	int hour = 0;
//	int minute = 0;
//	scanf("%d:%d", &hour, &minute);
//	if (hour < 12)
//	{
//		printf("%d:%d AM", hour, minute);
//	}
//	else if(hour==12)
//	{
//		printf("%d:%d PM", hour, minute);
//
//	}
//	else
//	{
//		printf("%d:%d PM", hour - 12, minute);
//
//	}
//	return 0;
//}




//模拟交通警察的雷达测速仪。输入汽车速度，如果速度超出60 mph，
//则显示“Speeding”，否则显示“OK”。

//输入格式：
//输入在一行中给出1个不超过500的非负整数，即雷达测到的车速。

//输出格式：
//在一行中输出测速仪显示结果，格式为：Speed : V - S，其中V是车速，S或者是Speeding、或者是OK。

//int main()
//{
//	int V = 0;
//	scanf("%d", &V);
//	if (V <= 60)
//	{
//		printf("Speed: %d - OK",V);
//	}
//	else
//	{
//		printf("Speed: %d - Speeding",V);
//	}
//	return 0;
//}




//三个球A、B、C，大小形状相同且其中有一个球与其他球重量不同。要求找出这个不一样的球。

//输入格式：
//输入在一行中给出3个正整数，顺序对应球A、B、C的重量。

//输出格式：
//在一行中输出唯一的那个不一样的球。
//int main()
//{
//	int A = 0;
//	int B = 0;
//	int C = 0;
//	scanf("%d%d%d", &A, &B, &C);
//	if (A == B)
//	{
//		printf("C");
//	}
//	else if (A == C)
//	{
//		printf("B");
//	}
//	else
//	{
//		printf("A");
//	}
//	return 0;
//}




//某公司员工的工资计算方法如下：一周内工作时间不超过40小时，按正常工作时间计酬；
//超出40小时的工作时间部分，按正常工作时间报酬的1.5倍计酬。
//员工按进公司时间分为新职工和老职工，进公司不少于5年的员工为老职工，5年以下的为新职工。
//新职工的正常工资为30元/小时，老职工的正常工资为50元/小时。请按该计酬方式计算员工的工资。

//输入格式：
//输入在一行中给出2个正整数，分别为某员工入职年数和周工作时间，其间以空格分隔。

//输出格式：
//在一行输出该员工的周薪，精确到小数点后2位。
//int main()
//{
//	double money = 0;
//	int workage = 0;
//	int worktime = 0;
//	scanf("%d%d", &workage, &worktime);
//	if (workage >= 5)
//	{
//		if (worktime <= 40)
//		{
//			money = worktime * 50;
//		}
//		else
//		{
//			money = 40 * 50 + (worktime - 40) * 50 * 1.5;
//		}
//	}
//	else
//	{
//		if (worktime <= 40)
//		{
//			money = worktime * 30;
//		}
//		else
//		{
//			money = 40 * 30 + (worktime - 40) * 30 * 1.5;
//		}
//	}
//	printf("%.2lf", money);
//	return 0;
//}




//为鼓励居民节约用水，自来水公司采取按用水量阶梯式计价的办法，居民应交水费y（元）与
//月用水量x（吨）相关：当x不超过15吨时，y=4x/3；超过后，y=2.5x−17.5。请编写程序实现水费的计算。

//输入格式：
//输入在一行中给出非负实数x。

//输出格式：
//在一行输出应交的水费，精确到小数点后2位。
//int main()
//{
//	double x = 0;
//	double y = 0;
//	scanf("%lf", &x);
//	if (x <= 15)
//	{
//		y = 4 * x / 3;
//
//	}
//	else
//	{
//		y = 2.5 * x - 17.5;
//	}
//	printf("%.2lf", y);
//	return 0;
//}





//本题要求编写一个简单计算器程序，可根据输入的运算符，
//对2个整数进行加、减、乘、除或求余运算。题目保证输入和输出均不超过整型范围。

//输入格式：
//输入在一行中依次输入操作数1、运算符、操作数2，其间以1个空格分隔。操作数的数据类型为整型，
//且保证除法和求余的分母非零。

//输出格式：
//当运算符为 + 、 - 、 * 、 / 、 % 时，在一行输出相应的运算结果。
//若输入是非法符号（即除了加、减、乘、除和求余五种运算符以外的其他符号）则输出ERROR。

//int main()
//{
//	int a = 0;
//	int b = 0;
//	char x = 0;
//	scanf("%d %c %d", &a, &x, &b);
//	switch (x)
//	{
//	case '+':
//		printf("%d", a + b);
//		break;
//	case '-':
//		printf("%d", a - b);
//		break;
//	case '*':
//		printf("%d", a * b);
//		break;
//	case '/':
//		printf("%d", a / b);
//		break;
//	case '%':
//		printf("%d", a % b);
//		break;
//	default:
//		printf("ERROR");
//
//
//	}
//	return 0;
//}






//股票价格涨跌趋势，常用蜡烛图技术中的K线图来表示，分为按日的日K线、按周的周K线、
//按月的月K线等。以日K线为例，每天股票价格从开盘到收盘走完一天，对应一根蜡烛小图，
//要表示四个价格：开盘价格Open（早上刚刚开始开盘买卖成交的第1笔价格）、收盘价格Close
//（下午收盘时最后一笔成交的价格）、中间的最高价High和最低价Low。

//如果Close<Open，表示为“BW - Solid”（即“实心蓝白蜡烛”）；如果Close>Open，
//表示为“R - Hollow”（即“空心红蜡烛”）；如果Open等于Close，则为“R - Cross”
//（即“十字红蜡烛”）。如果Low比Open和Close低，称为“Lower Shadow”（即“有下影线”），
//如果High比Open和Close高，称为“Upper Shadow”（即“有上影线”）。
//请编程序，根据给定的四个价格组合，判断当日的蜡烛是一根什么样的蜡烛。

//输入格式：
//输入在一行中给出4个正实数，分别对应Open、High、Low、Close，其间以空格分隔。

//输出格式：
//在一行中输出日K蜡烛的类型。如果有上、下影线，则在类型后加上with 影线类型。
//如果两种影线都有，则输出with Lower Shadow and Upper Shadow。
//int main()
//{
//	double Open = 0;
//	double Close = 0;
//	double High = 0;
//	double Low = 0;
//	scanf("%lf %lf %lf %lf", &Open, &High, &Low, &Close);
//	if (Close < Open)
//	{
//		if (Low < Open && Low < Close&&High>Open&&High>Close)
//		{
//			printf("BW-Solid with Lower Shadow and Upper Shadow");
//		}
//		else if (Low < Open && Low < Close)
//		{
//			printf("BW-Solid with Lower Shadow");
//		}
//		else if (High > Open && High > Close)
//		{
//			printf("BW-Solid with Upper Shadow");
//		}
//		else
//		{
//			printf("BW-Solid");
//
//		}
//	}
//	else if (Close > Open)
//	{
//		if (Low < Open && Low < Close && High>Open && High>Close)
//		{
//			printf("R - Hollow with Lower Shadow and Upper Shadow");
//		}
//		else if (Low < Open && Low < Close)
//		{
//			printf("R - Hollow with Lower Shadow");
//		}
//		else if (High > Open && High > Close)
//		{
//			printf("R - Hollow with Upper Shadow");
//		}
//		else
//		{
//			printf("R - Hollow");
//
//		}
//	}
//	else
//	{
//		if (Low < Open && Low < Close && High>Open && High>Close)
//		{
//			printf("R - Cross with Lower Shadow and Upper Shadow");
//		}
//		else if (Low < Open && Low < Close)
//		{
//			printf("R - Cross with Lower Shadow");
//		}
//		else if (High > Open && High > Close)
//		{
//			printf("R - Cross with Upper Shadow");
//		}
//		else
//		{
//			printf("R - Cross");
//
//		}
//	}
//	return 0;
//}






//给定两个整数A和B，输出从A到B的所有整数以及这些数的和。
//int main()
//{
//	int A = 0;
//	int B = 0;
//	int j = 0;
//	int sum = 0;
//	scanf("%d%d", &A, &B);
//	for (int i = A; i <= B; i++)
//	{
//		
//			printf("%5d", i);
//		
//		j++;
//		if (j % 5 == 0)
//		{
//			if (i != B)
//			{
//				putchar('\n');
//			}
//		}
//		sum += i;
//	}
//	putchar('\n');
//	printf("Sum = %d", sum);
//	return 0;
//}




//根据下面关系式，求圆周率的值，直到最后一项的值小于给定阈值。
//输入格式：
//输入在一行中给出小于1的阈值。
//输出格式：
//在一行中输出满足阈值条件的近似圆周率，输出到小数点后6位。
//int main()
//{
//	double x = 0;
//	double sum = 0;
//	double a = 0;
//	scanf("%lf", &x);
//	for (int i = 0, j = 1;; i++, j += 2)
//	{
//		double b = 1;
//		if (i == 0)
//		{
//			b = 1;
//		}
//		else
//		{
//			for (int k = i; k >= 1; k--)
//			{
//				b *= k;
//			}
//		}
//		double c = 1;
//		if (j == 1)
//		{
//			c = 1;
//		}
//		else
//		{
//			for (int n = 3; n <= 2 * i + 1; n += 2)
//			{
//				c *= n;
//			}
//		}
//		a = b / c;
//		sum += a;
//		if (a < x)
//		{
//			break;
//		}
//	}
//	printf("%.6lf", 2*sum);
//	return 0;
//}



//给定不超过6的正整数A，考虑从A开始的连续4个数字。请输出所有由它们组成的无重复数字的3位数。

//输入格式：
//输入在一行中给出A。

//输出格式：
//输出满足条件的的3位数，要求从小到大，每行6个整数。整数间以空格分隔，但行末不能有多余空格。
//int main()
//{
//	int A = 0;
//	int sum = 0;
//	scanf("%d", &A);
//	for (int i = A; i <= A + 3; i++)
//	{
//		for (int j = A; j <= A + 3;j++)
//		{
//			for (int k = A; k <= A + 3; k++)
//			{
//				if (i != j && i != k&&j!=k)
//				{
//					sum++;
//					if (sum %6 != 0)
//					{
//						printf("%d ", i * 100 + j * 10 + k);
//					}
//					else
//					{
//						printf("%d\n", i * 100 + j * 10 + k);
//						
//					}
//				}
//			}
//		}
//	}
//
//	return 0;
//}







//一条蠕虫长1寸，在一口深为N寸的井的底部。已知蠕虫每1分钟可以向上爬U寸，但必须休息1分钟才能接着往上爬。
//在休息的过程中，蠕虫又下滑了D寸。就这样，上爬和下滑重复进行。请问，蠕虫需要多长时间才能爬出井？

//这里要求不足1分钟按1分钟计，并且假定只要在某次上爬过程中蠕虫的头部到达了井的顶部，那么蠕虫就完成任务了。
//初始时，蠕虫是趴在井底的（即高度为0）。

//输入格式：
//输入在一行中顺序给出3个正整数N、U、D，其中D < U，N不超过100。

//输出格式：
//在一行中输出蠕虫爬出井的时间，以分钟为单位。
//int main()
//{
//	int N = 0;
//	int U = 0;
//	int D = 0;
//	int high = 0;
//	int time = 0;
//	scanf("%d%d%d", &N, &U, &D);
//	while (1)
//	{
//		if (N == 0)
//		{
//			time = 0;
//			break;
//		}
//		if (N <= U)
//		{
//			time = 1;
//			break;
//		}
//		high +=U;
//		time++;
//		if (high >= N)
//		{
//			break;
//		}
//		high -= D;
//		time++;
//	}
//	printf("%d",time);
//	return 0;
//}




//二分法求函数根的原理为：如果连续函数f(x)在区间[a,b]的两个端点取值异号，即f(a)f(b)<0，
//则它在这个区间内至少存在1个根r，即f(r)=0。

//二分法的步骤为：

//检查区间长度，如果小于给定阈值，则停止，输出区间中点(a + b) / 2；否则
//如果f(a)f(b) < 0，则计算中点的值f((a + b) / 2)；
//如果f((a + b) / 2)正好为0，则(a + b) / 2就是要求的根；否则
//如果f((a + b) / 2)与f(a)同号，则说明根在区间[(a + b) / 2, b]，令a = (a + b) / 2，重复循环；
//如果f((a + b) / 2)与f(b)同号，则说明根在区间[a, (a + b) / 2]，令b = (a + b) / 2，重复循环。
	
//输入格式：
//输入在第1行中顺序给出多项式的4个系数
	
//输出格式：
//在一行中输出该多项式在该区间内的根，精确到小数点后2位。
//int main()
//{
//	double a0 = 0;
//	double a1 = 0;
//	double a2 = 0;
//	double a3 = 0;
//	double a = 0;
//	double b = 0;
//	scanf("%lf%lf%lf%lf",&a3,&a2, &a1, &a0);
//	scanf("%lf%lf", &a, &b);
//	double ret = 0;
//	
//	while (1)
//	{ 
//	double c = (a + b) / 2;
//	double Fa = a3 * a * a * a + a2 * a * a + a1 * a + a0;
//	double Fb = a3 * b * b * b + a2 * b * b + a1 * b + a0;
//	double Fc = a3 * c * c * c + a2 * c * c + a1 * c + a0;
//	
//		if (Fa == 0)
//		{
//			ret =a;
//			break;
//		}
//		if (Fb == 0)
//		{
//			ret = b;
//			break;
//		}
//		double tmp = Fc;
//		if (Fc < 0)
//		{
//			tmp = -Fc;
//
//		}
//		
//		if (tmp <=0.000000000001)
//		{
//			ret = c;
//			break;
//		}
//		if ((Fc < 0 && Fb < 0)|| (Fc > 0 && Fb > 0))
//		{
//			b = c;
//		}
//		else if ((Fc < 0 && Fa < 0) || (Fc > 0 && Fa > 0))
//		{
//			a = c;
//
//		}
//
//	}
//	printf("%.2lf", ret);
//
//
//	return 0;
//}




//一个采购员去银行兑换一张y元f分的支票，结果出纳员错给了f元y分。采购员用去了n分之后才发觉有错，
//于是清点了余额尚有2y元2f分，问该支票面额是多少？

//输入格式：0.99     f+y/100-0.99=2y+2f/100
//输入在一行中给出小于100的正整数n。

//输出格式：
//在一行中按格式y.f输出该支票的原始面额。如果无解，则输出No Solution。
//int main()
//{
//	double y = 0;
//	double f = 0;
//	int n = 0;
//	scanf("%d", &n);
//	double n1 = n / 100.0;
//	
//	for (y = 0; y < 1000; y++)
//	{
//		for (f = 0; f < 1000; f++)
//		{
//			double x1 = f + y / 100;
//			double x2 = 2 * y + (2 * f) / 100;
//			if (x1 - n1 == x2)
//			{
//				goto aa;
//			}
//		}
//	}
//	printf("No Solution");
//	goto bb;
//	
//aa:
//	printf("%.0lf.%.0lf", y, f);
//bb:
//	return 0;
//}




//打印九九乘法表
//int main()
//{
//	int N = 0;
//	scanf("%d", &N);
//	for (int i = 1; i <= N; i++)
//	{
//		for (int j = 1; j <= i; j++)
//		{
//			printf("%d*%d=%-4d", j, i,i*j);
//		}
//		putchar('\n');
//	}
//	return 0;
//}






//输入在一行中给出正整数N（≤10000）。

//输出格式：
//输出方程X^2+ Y^2= N的全部正整数解，其中X≤Y。每组解占1行，两数字间以1空格分隔，按X的递增顺序输出。
//如果没有解，则输出No Solution。
/*int main()
{
	int N = 0;
	scanf("%d", &N);
	int flag = 0;
	for (int X = 0; X <= 100; X++)
	{
		for (int Y = 0; Y <= 100; Y++)
		{
			if (X * X + Y * Y == N && X <= Y)
			{
				printf("%d %d", X, Y);
				flag = 1;
				putchar('\n');
			}
		}
	}
	if (flag == 0)
	{
		printf("No Solution");
	}
	return 0;
}*/

